home *** CD-ROM | disk | FTP | other *** search
- ACK-3D
- ( Animation Construction Kit 3D )
-
-
- ******************************************************************************
- This file is included for completeness. It was originally distributed with
- the earlier version of the ACK engine and contains some of the technical notes
- used in the ray-casting technique. This file has not been edited for the new
- engine so some of the information may not apply. In general however, it gives
- a basic foundation for creation of one type of ray-casting engine.
- ******************************************************************************
-
-
- Disclaimer
-
- The author, Lary Myers, and any other persons referred to
- in this documentation or in the computer programs ACK3D and MAPEDIT
- accept no responsibility for any loss of time, money or productivity,
- or damage to any person(s) or computer hardware or software, as a
- result of using the programs ACK3D and MAPEDIT, even if the above
- mentioned had knowledge or had been notified of the possibilities
- of such events.
-
-
-
- Distribution and Usage
-
- Considerable thought has gone into just how the source code for ACK3D
- would be released. Some possibilities included providing only the construction
- kit and selling the source to interested parties, or providing the source to
- be used as freeware for private use but requiring license for commercial ventures,
- and so forth.
-
- What I've decided is to release all the source, header files, notes, etc
- into the public domain as "PUBLICWARE". You may freely use the engine source
- and associated files for the programs ACK3D and MAPEDIT anyway you see fit.
- One of the goals when I started this project was to place the means into other
- peoples hands, more talented than I, so they could then create worlds of
- adventure and entertainment for the rest of us to share in.
-
- Here is the one reservation that I must insist on.
-
- The author, Lary Myers, hereby grants the right to use, modify, and sell
- the source code provided in the ACK3D collection of files, with the stipulation
- that Lary Myers accepts no responsibilty for changes desired in the code, bug
- fixes, or future updates.
-
-
- Now, with all that aside, PLEASE let me know of any comments and/or
- suggestions you may have regarding possible uses for the engine and any
- enhancements you wish to share with me and others. The entire project is
- still far from over and together maybe we can create a powerful engine for
- use in a wide variety of applications.
-
-
-
- ------------------------------------------------------------------------------
- Programming notes:
-
- Author: Lary Myers
-
-
- Development system: 486DX 33Mhz
- 8 Meg RAM
- 210 Meg HD
- Boca VGA
- Microsoft mouse
-
- Borland C++ Version 3.1
- Microsoft Macro Assembler Version 5.00A
-
- Languages used: C and Assembler
-
- Model used: Compact
-
-
- ------------------------------------------------------------------------------
- Compiling the engine:
-
- 1. Place all of the files from the .ZIP file into one directory. Since I
- use Borland I opted for the following directory structure;
-
- \BORLANDC\ACK3D\SRC <- Contains all the source for the engine
-
- \BORLANDC\ACK3D\KIT <- Contains executables, images, for the kit
-
- 2. Several years ago I wrote a program called MK.EXE which was used to
- MAKE programs based on dependencies, etc. Even though the compilers
- nowadays have much better makes, I still use this old one of mine, so
- the .MAK files provided with the engine are based on using it with
- MK.EXE. You can either use them as is (if you have BorlandC) or use
- them to see what's needed to create a standard MAKE file. If you use
- MK then type in the following to begin the process;
-
- MK A <- This will build the ACK3D engine
-
- MK M <- This will build the Map Editor
-
-
-
- ------------------------------------------------------------------------------
- Goals:
- 1. Create a 3D graphic engine which visually mimics the Wolfenstein
- 3D game as a starting point, then add new features and interface.
-
- 2. Use the engine to create a generic construction kit.
-
- 3. Provide the source and construction kit to the general public.
-
-
- Techniques:
-
- The graphic engine is based on a technique called Ray Casting, a term
- that has been used to describe the process where a 2D representation of a
- maze is rendered in 3D. The details of Ray Casting are provided below;
-
- 1. Using a two dimensional map similiar to graph paper, a maze is built
- consisting of borders (walls) in both the X and Y planes. These walls
- describe the physical boundaries of the map. Figure 1 shows an example
- of a simple map.
-
-
- X
- ╔════╦════╦════╦════╦════╦════╦════╦════╦════╦════╦════╦════╗
- Y ║....║....║....║....║....║....║....║....║....║....║....║....║
- ║....║....║....║....║....║....║....║....║....║....║....║....║
- ╠════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╣
- ║....║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║....║
- ║....║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║....║
- ╠════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╣
- ║....║ ║ ║....║....║....║....║....║ ║ ║ ║....║
- ║....║ ║ ║....║....║....║....║....║ ║ ║ ║....║
- ╠════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╣
- ║....║ ║ ║....║ ║ ║ ║....║ ║ ║ ║....║
- ║....║ ║ ║....║ ║ ║ ║....║ ║ ║ ║....║
- ╠════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╣
- ║....║ ║ ║ ║ ║ ║ ║....║ ║ ║ ║....║
- ║....║ ║ ║ ║ ║ ║ ║....║ ║ ║ ║....║
- ╠════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╣
- ║....║ ║ ║....║ ║ ║ ║....║....║....║....║....║
- ║....║ ║ ║....║ ║ ║ ║....║....║....║....║....║
- ╠════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╣
- ║....║ ║ ║....║ ║ ║ ║ ║ ║ ║ ║....║
- ║....║ ║ ║....║ ║ ║ ║ ║ ║ ║ ║....║
- ╠════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╬════╣
- ║....║....║....║....║....║....║....║....║....║....║....║....║
- ║....║....║....║....║....║....║....║....║....║....║....║....║
- ╚════╩════╩════╩════╩════╩════╩════╩════╩════╩════╩════╩════╝
-
-
- ╔════╗
- ║....║ Indicates a square that has walls
- ║....║
- ╚════╝
-
- ╔════╗
- ║ ║ Indicates a blank square
- ║ ║
- ╚════╝
-
-
- Figure 1
-
-
-
-
- 2. The map is made up of cubes, each having a fixed size. For our
- purposes we'll use 64x64 units for each square. This allows an
- object (or player) to move 64 units in either the X or Y direction
- before moving into another square. The total map is made up of
- a number of squares to form rows and a number of rows to form a
- two dimensional array (again, just like graph paper has some number
- or sqaures by some number of rows of squares).
-
-
- 3. A player is then defined as a location on the map having three
- properties, an X and Y coordinate as well as an Angle that the
- player is currently facing. Figure 2 shows this relationship.
-
-
-
- ╔════╦════╦════╦════╦
- ║....║....║....║....║
- ║....║....║....║....║ P - The current location of the player
- ╠════╬════╬════╬════╬
- ║....║ ║ ║ ║ -> The current angle the player is facing
- ║....║ P->║ ║ ║
- ╠════╬════╬════╬════╬
- ║....║ ║ ║....║
- ║....║ ║ ║....║
- ╠════╬════╬════╬════╬
- ║....║ ║ ║....║
- ║....║ ║ ║....║
- ╠════╬════╬════╬════╬
-
-
- Figure 2
-
-
-
-
- 4. Once we know where the Player is and the current angle the player is
- facing, we can begin to determine what will be visible at that moment
- in time. To begin with, we need to decide on the field of vision that
- will be used. ACK3D uses a 60 degree field of vision to show the
- walls in a realistic setting. This means that the player will see all
- items 30 degrees to the left of the current viewing angle to 30 degrees
- to the right of the current angle. Figure 3 illustrates this.
-
-
-
- /
- / -30 degrees from viewing angle (VA - 30)
- /
- /
- P -------------> Current viewing angle (VA)
- \
- \
- \ +30 degrees from viewing angle (VA + 30)
- \
-
-
- Figure 3
-
-
-
-
-
- 5. As you can see, if we superimpose Figure 3 onto figure 2 we begin to
- get a field of vision which encompasses those walls in front of the
- player (at the current viewing angle). This gives us Figure 4.
-
-
-
- 0 1 2 3
- ╔════╦════╦════╦════╦
- 0 ║....║....║.../║....║
- ║....║....║./..║....║ P - The current location of the player
- ╠════╬════/════╬════╬
- 1 ║....║ / ║ ║ ║ -> The current angle the player is facing
- ║....║ P--------> ║
- ╠════╬══\═╬════╬════╬
- 2 ║....║ \ ║....║
- ║....║ ║ \ ║....║
- ╠════╬════╬═══\╬════╬
- 3 ║....║ ║ ║....║
- ║....║ ║ ║....║
- ╠════╬════╬════╬════╬
-
-
- Figure 4
-
-
-
- 6. What the user (player) should see at this point is shown in Figure 5,
- where the double border represents the screen with the walls displayed
- inside.
-
-
-
-
- ╔═══════════════════════════════════╗
- ║ / ║
- ║ / ║
- ║ / ║
- ║┌───────────────────────────┐ ║
- ║│ │ ║
- ║│ │ ║
- ║│ │ ║
- ║│ │ ║
- ║│ │ ║
- ║│ │ ║
- ║│ │ ║
- ║│ │ ║
- ║└───────────────────────────┘ ║
- ║ \ ║
- ║ \ ║
- ║ \ ║
- ╚═══════════════════════════════════╝
-
-
- Figure 5
-
-
-
- 7. So, how do we get from a flat 2 dimensional map to the appearance of
- 3D walls? By calculating the height of the walls as a function of
- distance. Given the current X,Y coordinates of the player and the
- X,Y coordinates of the wall, we can use trigonometry to figure out
- the distance between the player and the wall. The real trick is to
- perform these calculations with the speed necessary to show realistic
- movement in our 3D environment. We'll get into that in a moment. Right
- now, lets look at the brute force method of determining how far the
- walls are. The first thing to remember is that we will be casting a
- ray for each column of the screen. Using VGA mode 13h this gives us
- 320 columns by 200 rows. So, 320 rays will be cast out to fill the
- screen with our field of view.
-
-
-
- 8. Lets begin by setting some initial values for the player. We said in
- section 2 that each square was 64 by 64 units in size. Looking at
- Figure 4 we see that the player is in square 1,1 about 3/4 the way
- down from the top of the square and about 1/4 the way over from the
- right side of the square. This puts our player X,Y at roughly 80,112.
- The current viewing angle will be 0 for this part of the discussion.
-
- Since we are going to use the trig functions provided in the C libraries,
- we can draw a coordinate system where the angle increases in a clockwise
- direction, giving us Figure 6;
-
-
- 270
- │ 330
- │ /
- │/
- 180 ─────O───── 0
- │\
- │ \
- │ 30
- 90
-
- Figure 6
-
-
- 9. Therefore, as mentioned in section 4, we begin our cast 30 degrees to
- the left of the current view angle, or at 330 degrees, and continue
- until we are 30 degrees to the right of the view angle, which will be
- at +30 degrees. As you can see, we can form a right triangle from the
- player position to the point at angle 330.
-
-
- Opp
- Tan = ---
- /│ Adj
- Hyp / │
- / │Opp Adj
- / Angle│ Cos = ---
- P────────┘ Hyp
- Adj
-
- Opp
- Sin = ---
- Hyp
- Figure 7
-
-
-
- 10. What we want to do at this point is draw an imaginary line from the
- player out to some point at angle 330. But how far do we draw the
- line? As far as needed to encounter a wall or until we leave the outside
- boundaries of the map. Lets say our map is 10 squares across by 8
- rows down. That gives us 80 squares total. The maximum width of our
- map is therefore 64 units times 10 or 640 units, by 64 units times 8
- rows or 512 units. The maximum distance we ever have to look is given
- be the equation;
-
-
-
- c2 = a2 + b2 (c squared = a squared plus b squared)
-
- or
-
- c2 = 640 squared plus 512 squared
-
-
- which gives 819.5999 or 820 units
-
-
- Equation 1
-
-
-
- So, 820 units is how far we'll cast each ray, checking along the way
- for a wall or a boundary condition. We can use the well established
- Bresenham's line drawing algorithm to plot each point along the line
- to see what it strikes. We begin by determining the endpoints of the
- line. The equations for a point on a circle gives us the X and Y
- points we need;
-
-
- X1 = X + (cos(angle) * distance)
-
- Y1 = Y + (sin(angle) * distance)
-
-
-
- Equation 2
-
-
- Using the numbers from section 8 and section 10 we get the following;
-
-
- X1 = 80 + (cos(330) * 820)
-
- Y1 = 112 + (sin(330) * 820)
-
-
- which gives;
-
- X1 = 790
-
- Y1 = -298
-
-
- Passing the coordinates 80,112,790,-298 into a line routine we begin
- to check for intercepts with walls. At each point along the line we
- calculate our map position with the following equation;
-
-
-
- MapPosn = ( Y / 64 ) * 10 + ( X / 64 )
-
-
- Recalling that our map was 10 squares across and each square was 64
- by 64 units in dimension.
-
-
- Looking back at Figure 4 we see that our first intercept will come when
- the line passes into square 2,0. At this very point we have struck a
- wall and can then determine the distance to that wall. We'll call the
- point Wx and Wy to distinguish them from our line endpoints. Using
- Equation 1 again we can determine the distance to the wall;
-
-
- c2 = a2 + b2
-
-
- c2 = (Wx - x) squared plus (Wy - y) squared
-
-
- Equation 2
-
-
-
- From the drawing scale in Figure 4, it appears a wall is encounterd
- at coordinates 128,128 in square 2,0, so we can use numbers in the
- above to get;
-
-
- c2 = (128 - 80) squared plus (128 - 112) squared
-
-
- which gives us;
-
-
- Distance = 50.596 units or 51 units rounded up
-
-
- Using this distance we can look up the height from a precalculated table
- to see how high the wall should appear on the screen.
-
-
-
- We continue this process for each column of the screen until we have
- a 320 columns of graphic walls displayed, each column showing the walls
- at a certain height, which gives the illusion of distance.
-
-
- As you may have already surmised, we don't advance our ray casting by
- whole degree increments, instead we move in 60/320 degrees or 0.1875
- increments to give us a 60 degree field of view in 320 columns of
- the video screen.
-
-
- This method was initially used by the ACK3D engine and can be summarized
- with the following;
-
-
- a. Take the current viewing angle of the player and subtract 30 from
- it to get the cast angle.
-
- b. Calculate an X and Y endpoint using the players X,Y coordinates,
- the cast angle, and a maximum distance to cast the ray.
-
- c. Using Bresenham's line drawing algorithm, plot each point along the
- line and look for an intercept with a wall or the point where the
- line goes outside of the map boundaries. If a wall is found, return
- the Wx and Wy point of the wall intercept.
-
- d. Using the players X,Y coordinates, and the Wall Wx,Wy coordinates,
- calculate the distance to the wall using Equation 2.
-
- e. Use the distance to look up in a table to get the height of the
- wall to display.
-
- f. Add 0.1875 to the cast angle and go back to step b until 320 rays
- have been cast.
-
-
- Method 1
-
-
-
-
- 11. The above discussion was presented in order to give the reader some
- background into the train of thought for ray casting. While Method 1
- did work and did produce a semi-reasonable display, some major problems
- were seen, these can be summarized as;
-
-
- a. Speed - Casting a line along every point for 320 rays was just
- plain SLOW! The screen could actually be seen updating
- from left to right as the rays were cast! (This was without
- any optimizations in the ray casting routines).
-
-
- b. Accuracy - Floating point was used in order to get the needed
- increments in angles and distance, but a problem with
- roundoff still occurred. Some of this was attributable
- to the code (This was pointed out to me by those who
- looked at the routines - my thanks to you all!). But,
- some of it was due to the method itself.
-
-
- c. Intercepts - There was no easy way to determine if we had hit a
- wall on the X or Y borders of the square. One method
- that could have been used was to determine if the
- Wx and Wy points fell on an even 64 boundary, but
- this was never tried. Once we found the correct
- intercept, there was still the problem of determining
- which column of the wall should be drawn.
-
-
-
- ------------------------------------------------------------------------------
-
- Optimized Ray Casting:
-
-
-
- 1. Once it was determined that the method was viable, albiet with its
- problems, a more advanced or optimized method could be tried. This
- is how ACK3D evolved.
-
- 2. Many of the givens could be carried forward into the new version, we
- would still use squares on a map, each square being 64 units wide by
- 64 units tall. The player properties could still be used, giving us
- an X,Y coordinate pair and a current angle that the player is facing.
- The total viewing angle could remain at 60 degrees with a sweep from
- -30 degrees to the left to +30 degrees to the right of the current
- player angle.
-
- 3. The first order of business was to get rid of the floating point. By
- using fixed point numbers we could attain a speedup in the overall
- process. Fixed point numbers are beyond this discussion but essentially
- a fixed point number is where a given number is shifted a certain
- amount to the left to retain the fractional part of the number. This
- new value is then used in a calculation and the result is shifted back
- to the right to remove the fractional part. ACK3D uses two fixed point
- ranges to perform its calculations, the first being a 16 bit shift and
- the second being a 20 bit shift (which we'll get into soon).
-
- 4. The next thing was to begin using tables for most of the housekeeping
- calculations. Since we knew that our viewing angles were in 0.1875
- degree increments we could precalculate sine and cosine tables (as well
- as tangent) ahead of time. Our full circle would therefore become
- 360 / 0.1875 or 1920 entries in the tables. Every angle from 0 to 360
- was calculated, multiplied by 65536 (our 16 bit shift for fixed point)
- and written out to a file. Now if we needed to find the cosine of
- 330 degrees, we could use 330/0.1875 or 1760 to lookup in the cosine
- table and get the value 56759 (after rounding). The same holds true
- for sine and tangent tables (and some others) as well.
-
- 5. Now, how to speed up drawing an imaginary line from the player to a
- point off in the distance? Looking at the map it becomes apparent that
- each square is a fixed distance from each other. That is where the
- speedup can be found. Lets break the process down further in that
- we only want to look for walls that fall on the X side and then walls
- that fall on the Y side of the square. This means we have to cast
- two rays for every angle, but it also means we know in advance which
- intercept will occur.
-
-
-
- 0 1 2 3
- ╓────╥────╥────B────╥
- 0 ║....║....║.../║....║
- ║....║....║./..║....║ P - The current location of the player
- ╟────╫────A────╫────╫
- 1 ║....║ / ║ ║ ║ -> The current angle the player is facing
- ║....║ P--------> ║
- ╟────╫──\─╫────╫────╫
- 2 ║....║ C ║....║
- ║....║ ║ \ ║....║ ║ Walls on the X side
- ╟────╫────╫───\╫────╫
- 3 ║....║ ║ D....║ ─ Walls on the Y side
- ║....║ ║ ║....║
- ╟────╫────╫────╫────╫
-
-
- Figure 8
-
-
-
-
- 6. Figure 8 shows our section of the map with only the X walls given as
- double lines, the Y walls (which we'll ignore for now) all fall on the
- single lines. From this we can see that a ray looking only for X walls
- will intercept at points A and B at angle 330 (The scale and angles
- are not precise due to text mode limitations, for the sake of discussion
- lets assume that the angle is 330). We also see that points C and D will
- be struck at our rightmost angle of 30 degrees. This gives us a method
- to optimize the ray casting algorithm into the following;
-
- a. Subtract 30 degrees from the current player angle to get the
- viewing angle.
-
-
- b. Determine the Y intercept of the current square based on the view
- angle and the X coordinate (note that the X coordinate will be the
- right side of the current square if our view angle falls between
- 270 degrees and 90 degrees and it will be the left side of the
- current square if our view angle falls between 90 degrees and
- 270 degrees). This X,Y intercept of the current square will be
- the first point we look for a wall.
-
- By using the tangent or inverse tangent of the view angle we can
- calculate the Y or X offset depending on which ray we are casting.
- This gives us a starting point in the current square to begin
- looking for walls.
-
- Knowing the width of each square is 64 we determine the next
- Y coordinate that our ray will fall on if we increase (or decrease)
- the X intercept by 64. This can be pre-calculated and placed in a
- table. We continue stepping both the X and Y coordinates with
- addition until a wall is hit or we leave the boundaries of the map.
- By using Equation 1 again we see that a maximum of 13 (rounded)
- points along any given line is all we will ever need to traverse
- the maximum distance in the map. Thats 13 points verses 820
- from the previous method!
-
-
- c. Once a wall is struck we use the Y coordinate to determine what
- column of the wall to display (Y AND 63) and the X coodinate to
- determine the distance (WITHOUT USING SQUARE ROOT).
-
-
- d. We flip the process around and perform a ray cast for walls that
- fall along the Y side of the square, using the X coordinate to
- determine the column of the wall and Y coordinate to determine
- the distance.
-
-
- e. Comparing the distance from the Xray and the distance from the
- yRay for whichever is closer we get the actual wall and wall
- column to display.
-
-
- f. Next, we advance our view angle by one unit in our 1920 entry
- circle and loop back to step b until 320 ray pairs have been
- cast.
-
- ------------------------------------------------------------------------------
- Determining the height of the bitmap:
-
- 1. Once we have the distance to the wall we need to look up the display
- height of the bitmap from our table. This table was pre-calculated
- and is based on dividing the distance into an experimentally derived
- number (that means I tried a variety of values until one looked the
- best!). For ACK3D this turned out to be 18000. All distances from
- 1 to our max distance are divided into this number to get a height
- value to draw the bitmap. Heights which are too big or too small are
- set to the maximum or minimum values respectively.
-
-
- ------------------------------------------------------------------------------
- Objects within our world:
-
- 1. Dealing with objects turned out to be a completely different problem.
- One that wasn't apparent from the effort put into the wall algorithm.
- The goal was to present an object to the user that did not show the
- same effects with angles as the walls, in other words, I didn't want
- objects to have corners when looking at them diaganally. This meant
- the distance to the object should not be dependent on either the X or
- the Y ray but should be based on a line of sight ray cast from the
- players current position.
-
- 2. After much experimenting and head scratching it was decided to treat
- objects using more traditional 3D methods. But, the speed still had
- to be considered!
-
- 3. Again, the brute force method would be to have all of the objects X
- and Y coordinates in a table. Each object is then translated to base
- 0,0 from the player and rotated into the field of vision. If the final
- X,Y location of the object fell within the 60 degree field of vision
- then the object would be visible and handled by the drawing routines.
- But what if there were many objects in this table? The time expended
- to check each object soon becomes a function of the number of objects
- that exist. No, some faster way had to be found.
-
- 4. So, by combining the ray casting with the process in section 3 above
- we could eliminate all objects not within the current field of vision
- thereby reducing the amount of calculations needed.
- This is the process;
-
- a. During the ray casting process described in section 6 above, also
- look in the object map to see if an object exist. If so, add the
- object to a list and set a flag saying the object has been seen.
- This flag prevents other near-angle rays from adding the same
- object to the list, only one entry is needed.
-
- b. Sort the object in the list with nearer objects being pushed down
- and farther objects being near the top. This way when the objects
- are later drawn the closer ones will hide objects that may be
- farther away and at the same angle.
-
- c. Continue the ray casting past the object just found. This allows
- us to find additional objects and finally any walls that may be
- in the line of sight. What gets returned to the caller of the
- ray casting routine is always the wall information, never any
- objects (since objects are stored in a global list).
-
- d. Once all the rays for the entire screen are cast we then draw the
- walls into the off-screen video buffer. Now its time to check for
- the objects.
-
- e. Using the list built during the ray casting we perform the
- laborious task of translating and rotating the objects coordinates
- relative to the players position and angle. This gives us final
- coordinates that we can use to determine where to place the object
- on the screen and what column to begin drawing the object. As we
- begin drawing, the distance to the object is checked against the
- distance to the corresponding wall. If the wall is closer, the
- object is not drawn in that column. We don't need to check the
- current object against all the other objects because they were
- sorted by distance when found, they'll cover up objects farther
- away by default.
-
- f. This process continues until all objects have been displayed in
- the list. Each time the routine is called to draw the screen we
- clear out the object seen flags and set the object count back
- to zero. This allows us to start fresh with finding any objects
- in our field of vision.
-
-
- ------------------------------------------------------------------------------
- VGA Mode X:
-
- 1. During initial development it was decided to use the undocumented
- VGA mode X (From Michael Aprash's articles in DDJ) which allow
- off-screen drawing and page flipping. This worked reasonably well
- on fast machines, but slower machines still had problems.
-
- 2. The normal VGA 320x200 mode 13H has also been tried with good results,
- but it is necessary to draw to a memory buffer (the way objects are
- currently handled) and then copy the system memory buffer to the
- screen. While it is a fast and straight forward process to move the
- 64,000 bytes from memory to video, it was still not fast enough to
- use on slower machines.
-
- 3. Experimenting has shown that it is possible to setup a screen mode
- that gives 320x200 resolution but still has multiple pages, etc. This
- cuts back on the number of screen writes needed (320 columns by 40
- rows) and has shown a definite increase in performance.
-
- 4. By way of the experimenting, the following files have been developed
- to try various methods.
-
- ACKASM.ASM - This is the current in-use file which sets multiple plane
- 320x200 mode.
-
- ACKASM.VGA - This uses normal VGA 320x200 mode 13h
-
- ACKASM.240 - This uses 320x240 mode X
-
- These files can be used in place of one another to test the engine
- in the various modes.
-
-
- ------------------------------------------------------------------------------
- Final comments:
-
- ACK3D has evolved over the past few weeks into a reasonable 3D graphics
- engine and I am fairly pleased with the results thus far. There are,
- however some annoying nuances that still plague the engine. These can be
- summarized as follows, and in the words of most books "The rest is left
- as an exercise for the reader" (Man I hate those words!).
-
- a. Accuracy at certain angles is still an issue, every so often a wall
- sliver appears where it shouldn't, at least at the wrong height
- anyway.
-
- b. Objects are getting clipped off the screen when thier centerpoint
- is reached. They should be partially visible even if the center is
- not.
-
- c. Collision detection is far from perfect. A better method needs to
- be devised to handle coming up to walls and objects at any angle.
-
- d. Secret doors are mariginally working. They should be used with care
- since the side walls of the moving door are invisible until the
- secret door comes to a rest.
-
- e. Object movement is restricted to always turning right when bumping
- into an obstacle. This needs to have more smarts built in to allow
- moving objects to do things like chase the player, or run away, or
- follow some predetermined path, etc.
-
- f. Other types of doors, besides secret and sliding doors needs to be
- implemented. Future versions of the engine will handle a variety of
- doors to deal with different uses of the engine.
-
- g. The goal actions need to be enhanced beyond displaying a screen that
- says something on the order of YOU WON! I mean really....
-
-
-
- I hope this discussion, and the 3D engine itself, prove to be a good
- starting point for your own creations. Many possibilities exist for this
- type of environment ranging from underground dungeons, to space stations,
- to art galleries. All thats needed is the right combination of graphics,
- sound, and storyline.
-
-
- Sincerely,
- Lary Myers
- 5 Jacob Street
- Ballston Lake, NY 12019
-
- CIS Account: 76004,1574
-
-
-